home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok24.lha / DME / SRC / source.zoo / rexx.c < prev    next >
C/C++ Source or Header  |  1989-07-03  |  6KB  |  250 lines
  1.  
  2. /*
  3.  *  REXX.C
  4.  *
  5.  *      (c) Copyright 1987 by Kim DeVaughn, All Rights Reserved
  6.  *
  7.  *  ARexx interface code, etc.
  8.  *
  9.  */
  10.  
  11.  
  12. #include "defs.h"
  13. #include "rexx.h"
  14.  
  15. #if AREXX
  16.  
  17. int foundcmd;       /* control for implicit ARexx macro invocation   */
  18. int cmderr;         /* global command error flag for do_rexx()'s use */
  19.  
  20. /*
  21. APTR OpenLibrary();
  22. APTR FindPort();
  23. APTR GetMsg();
  24. */
  25. APTR CreateRexxMsg();
  26. APTR CreateArgstring();
  27.  
  28. struct RxsLib *RexxSysBase;
  29.  
  30.  
  31.  
  32. /*
  33.  * initialization for ARexx ... just open rexsyslib.library
  34.  */
  35.  
  36. void
  37. openrexx()
  38. {
  39.     RexxSysBase = (struct RxsLib *)OpenLibrary("rexxsyslib.library", (ULONG)RXSVERS);
  40.     return;
  41. }
  42.  
  43.  
  44.  
  45. /*
  46.  * cleanup any open ARexx stuff ...  just close rexsyslib.library for now
  47.  */
  48.  
  49. void
  50. closerexx()
  51. {
  52.     if (RexxSysBase) {
  53.         CloseLibrary(RexxSysBase);
  54.     }
  55.     return();
  56. }
  57.  
  58.  
  59.  
  60. /*
  61.  *  explicit invocation interface between do_command() and do_rexx
  62.  *  for ARexx macros having NO arguments (i.e., for the "rx" command)
  63.  */
  64.  
  65. do_rx()
  66. {
  67.     do_rexx(av[1]);
  68.     return();
  69. }
  70.  
  71.  
  72.  
  73. /*
  74.  *  explicit invocation interface between do_command() and do_rexx
  75.  *  for ARexx macros having ONE argument (i.e., for the "rx1" command)
  76.  */
  77.  
  78. do_rx1()
  79. {
  80.     char macbuf[256];
  81.  
  82.     strcpy(macbuf, av[1]);
  83.     strcat(macbuf, " ");
  84.     strcat(macbuf, av[2]);
  85.     do_rexx(macbuf);
  86.     return();
  87. }
  88.  
  89.  
  90.  
  91. /*
  92.  *  explicit invocation interface between do_command() and do_rexx
  93.  *  for ARexx macros having TWO arguments (i.e., for the "rx2" command)
  94.  */
  95.  
  96. do_rx2()
  97. {
  98.     char macbuf[256];
  99.  
  100.     strcpy(macbuf, av[1]);
  101.     strcat(macbuf, " ");
  102.     strcat(macbuf, av[2]);
  103.     strcat(macbuf, " ");
  104.     strcat(macbuf, av[3]);
  105.     do_rexx(macbuf);
  106.     return();
  107. }
  108.  
  109.  
  110.  
  111. /*
  112.  *  implicit invocation interface between do_command() and do_rexx
  113.  *  for ARexx macros implicitly called; arbitrary number of arguments
  114.  */
  115.  
  116. do_rxImplied(cmd, args)
  117. char *cmd;
  118. char *args;
  119. {
  120.     char macbuf[256];
  121.  
  122.     strcpy(macbuf, cmd);
  123.     strcat(macbuf, " ");
  124.     strcat(macbuf, args);
  125.     do_rexx(macbuf);
  126.     return();
  127. }
  128.  
  129.  
  130.  
  131. /*
  132.  *  issue a command to ARexx ...
  133.  */
  134.  
  135. do_rexx(macstr)
  136. char *macstr;
  137. {
  138.     struct RexxArg *macarg;
  139.  
  140.     struct MsgPort  RexxPort;
  141.     struct MsgPort *ARexxPort;
  142.  
  143.     struct RexxMsg *macptr;
  144.     struct RexxMsg *cmdptr;
  145.  
  146.     char host[16];
  147.     char hexbuf[12];        /* should only need 9 bytes */
  148.     char errmsg[80];        /* don't build a larger error message */
  149.  
  150.     int  ret;
  151.     int  err;
  152.  
  153.  
  154.     if(*macstr == '#')
  155.         return(0);
  156.     if (RexxSysBase == 0) {
  157.         title("Unknown Command   -   No Macros:  ARexx Not Installed ");   /* no rexxsyslib */
  158.         return(0);
  159.     }
  160.  
  161.  
  162.     ClearMem(&RexxPort, sizeof(struct MsgPort));
  163.     strcpy(host, "DME");
  164.     sprintf(hexbuf, "%08x", &RexxPort);
  165.     strcat(host, hexbuf);
  166.     InitPort(&RexxPort, host);      /* need to error check this */
  167.     AddPort(&RexxPort);
  168.     /* return here if InitPort failed */
  169.  
  170.  
  171.     if (macarg = (struct RexxArg *)CreateArgstring(macstr, strlen(macstr))) {
  172.         if (macptr = (struct RexxMsg *)CreateRexxMsg(&RexxPort, "dme", host)) {
  173.             ACTION(macptr) = RXCOMM;
  174.             ARG0(macptr)   = (STRPTR)macarg;
  175.  
  176.             Forbid();
  177.             if (ARexxPort = (struct MsgPort *)FindPort("REXX")) {
  178.                 PutMsg(ARexxPort, macptr);
  179.                 Permit();
  180.                 title("Calling ARexx Macro ... ");
  181.  
  182.                 for (;;) {
  183.                     WaitPort(&RexxPort);
  184.                     cmdptr = (struct RexxMsg *)GetMsg(&RexxPort);
  185.  
  186.                     if (IsRexxMsg(cmdptr)) {
  187.  
  188.                         foundcmd = 0;
  189.                         cmderr = CMD_INITIAL;
  190.                         ret = do_command(ARG0(cmdptr));
  191.                         err = cmderr;
  192.                         if (foundcmd) {
  193.                             ret = (ret == 1) ? 0 : 5;   /* cmd error:  RC = 5  */
  194.                         } else {
  195.                             ret = do_rexx(ARG0(cmdptr));    /* another macro? */
  196.                         }
  197.  
  198.                         RESULT1(cmdptr) = ret;
  199.                         RESULT2(cmdptr) = 0;
  200.                         ReplyMsg(cmdptr);
  201.                     }
  202.                     do_command("null");     /* a kludge to set "foundcmd" */
  203.                     if (macptr == cmdptr) break;
  204.                 }
  205.  
  206.  
  207.                 if (ret = RESULT1(cmdptr)) {
  208.                     if (RESULT2(cmdptr)) {
  209.                         if (RESULT2(cmdptr) == 1) {
  210.                             title("Unknown Command ");
  211.                         } else {
  212.                             sprintf(errmsg, "ARexx Macro Error:  Code = %d  Severity = %d ", RESULT2(cmdptr), ret);
  213.                             title(errmsg);
  214.                         }
  215.                     } else {
  216.                         sprintf(errmsg, "User Specified Macro Error:  RC = %d ", ret);
  217.                         title(errmsg);
  218.                     }
  219.                 } else {
  220.                     if (err <= TITLE_THRESHHOLD) {
  221.                         title("OK ");
  222.                     }
  223.                 }
  224.                 ret = ret + err;
  225.             } else {
  226.                 Permit();
  227.                 title("Unknown Command   -   No Macros:  ARexx Not Active ");   /* no REXX port */
  228.  
  229.                 ret = -1;
  230.             }
  231.             DeleteRexxMsg(macptr);
  232.         } else {
  233.             title("CreateRexxMsg() Failed ");   /* may be overkill, and not need to ckeck this */
  234.             ret = -1;
  235.         }
  236.         DeleteArgstring(macarg);
  237.     } else {
  238.         title("CreateArgstring() Failed ");     /* may be overkill, and not need to check this */
  239.         ret = -1;
  240.     }
  241.  
  242.  
  243.     RemPort(&RexxPort);
  244.     FreePort(&RexxPort);
  245.     return(ret);
  246. }
  247.  
  248. #endif
  249.  
  250.